package com.wolfstreet.wsonline.util;

import java.util.Vector;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/******************************************************************
 * 文件名称 : DBHelper.java 文件描述 : 本类主要是对数据库进行的一系列操作
 ******************************************************************/

public class DBHelper extends SQLiteOpenHelper {
	/**
	 * 打印日志时日志信息中的标识符
	 */
	// private static final String TAG = "DBHelper";

	/**
	 * 数据库的名称
	 */
	public static String DATABASE_NAME = "chxx.db";

	/**
	 * 数据库的版本号，默认情况下是1
	 */
	private static final int DATABASE_VERSION = 1;

	/**
	 * 存储用户信息的数据表
	 */
	public static final String TABLE_USER = "table_user";

	/**
	 * 存储第三方调用标记
	 */
	public static final String TABLE_TOKEN = "table_accesstoken";

	/**
	 * 用来操作的数据库的实例
	 */
	SQLiteDatabase db = null;

	/**
	 * 构造函数
	 * 
	 * @param context
	 *            UI环境上下文
	 */
	public DBHelper(Context context) {
		super(context, DATABASE_NAME, null, DATABASE_VERSION);
	}

	/**
	 * 数据库在建立的时候执行的操作，主要是新建系统所需的数据表
	 */
	@Override
	public void onCreate(SQLiteDatabase db) {
		db.beginTransaction();
		try {
			//
			db.execSQL("create table if not exists " + TABLE_USER
					+ "(name text primary key,pwd text,type text)");

			db.execSQL("create table if not exists " + TABLE_TOKEN
					+ "(tp_id Integer primary key," + "access_token text,"
					+ "nick_name text," + "type text," + "openid text,"
					+ "end_time text)");

			db.setTransactionSuccessful();
		} catch (Exception e) {
			// Log.e("  create tables", e.getMessage());
			e.printStackTrace();
		} finally {
			db.endTransaction();
		}
	}

	/*
	 * 版本升级，数据库更新
	 */
	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

	}

	/**
	 * 插入数据
	 * 
	 * @param tableName
	 *            要插入的表格的名称
	 * @param values
	 *            要插入的数据由数据名称和数据值组成的键值对
	 * 
	 */
	public void insert(String tableName, ContentValues values) {
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			db.insert(tableName, null, values);
			db.setTransactionSuccessful();
		} catch (Exception e) {
		} finally {
			db.endTransaction();
		}
	}

	/**
	 * 批量插入数据
	 * 
	 * @param tableName
	 *            要插入的表格的名称
	 * @param values
	 *            要插入的数据由数据名称和数据值组成的键值对
	 * 
	 */
	public void insertByBatch(String tableName, Vector<ContentValues> values) {
		if (values.size() == 0)
			return;
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			for (ContentValues value : values) {
				db.insert(tableName, null, value);
			}
			db.setTransactionSuccessful();
		} catch (Exception e) {
		} finally {
			db.endTransaction();
		}
	}

	/**
	 * 对数据库中数据的删除操作
	 * 
	 * @param tableName
	 *            删除操作中要操作的数据表的名称
	 * @param whereArgs
	 *            要删除的数据中提供的条件参数的名称
	 * @param whereArgsValues
	 *            要删除的数据中提供的条件参数的值
	 */
	public void delete(String tableName, String[] whereArgs,
			String[] whereArgsValues) {
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			// 当传入的参数为空时，表示操作所有的记录
			if (whereArgs == null) {
				db.delete(tableName, null, null);
				// LogX.trace(TAG + "============s
			} else {
				// 当传入的参数为一个时
				if (whereArgs.length == 1) {
					// 当传入的参数和参数值分别为一个时
					if (whereArgsValues.length == 1) {
						db.delete(tableName, whereArgs[0] + " = ?",
								whereArgsValues);
						// LogX.trace(TAG + "=================" + tableName,
						// "Delete Success!");
					}
					// 当传入的参数为一个，参数值为多个时
					else {
						db.execSQL(del_SQL(
								tableName,
								createSQL(whereArgs, whereArgsValues,
										whereArgsValues.length)));
						// LogX.trace(TAG + "=================" + tableName,
						// "Delete Success!");
					}
				}
				// 当传入的参数和参数值分别为多个时，并且参数和参数值是一一对应的
				else {
					db.execSQL(del_SQL(
							tableName,
							createSQL(whereArgs, whereArgsValues,
									whereArgs.length)));
					// LogX.trace(TAG + "=================" + tableName,
					// "Delete Success!");
				}
			}
			db.setTransactionSuccessful();
		} catch (Exception e) {
			// LogX.trace(TAG + "=================" + tableName,
			// "Delete Error!");
		} finally {
			db.endTransaction();
		}
	}

	/**
	 * 将用户提供的参数拼接成一条完整的删除数据库的SQL语句
	 * 
	 * @param tableName
	 *            要操作的表的名称
	 * @param whereArgs
	 *            删除数据的条件参数
	 * @param whereArgsValues
	 *            删除数据的条件参数的值
	 * @param num
	 *            提供的条件中参数的个数
	 * @return 拼接完成后的删除SQL语句
	 */
	private String createSQL(String[] whereArgs, String[] whereArgsValues,
			int length) {
		StringBuffer sql = new StringBuffer(" ");
		// 当传入的参数为一个时
		if (whereArgs.length == 1) {
			for (int i = 0; i < length; i++) {
				sql.append(whereArgs[0] + " = '" + whereArgsValues[i] + "'");
				if (i < length - 1) {
					sql.append(" or ");
				}
			}
		}
		// 当传入的参数和参数值分别为多个时，并且参数和参数值是一一对应的
		else {
			for (int i = 0; i < length; i++) {
				sql.append(whereArgs[i] + " = '" + whereArgsValues[i] + "'");
				if (i < length - 1) {
					sql.append(" and ");
				}
			}
		}
		return sql.toString();
	}

	/**
	 * 生成删除数据的sql语句
	 * 
	 * @param tableName
	 *            要操作的数据表的名称
	 * @param str_sql
	 *            where语句部分
	 * @return
	 */
	private String del_SQL(String tableName, String str_sql) {
		return new StringBuffer("delete from " + tableName + " where "
				+ str_sql).toString();
	}

	/**
	 * 对数据进行的查询操作
	 * 
	 * @param tableName
	 *            需要操作的表名
	 * @param whereArgs
	 *            要查询的数据中提供的条件参数的名称
	 * @param whereArgsValues
	 *            要查询的数据中提供的条件参数的值
	 * @param column
	 *            控制哪些字段返回结果（传null是返回所有字段的结果集）
	 * @param orderBy
	 *            是否对某一字段进行排序（传null不进行排序）
	 * @return 查找的数据集的指针
	 */
	public Cursor query(String tableName, String[] whereArgs,
			String[] whereArgsValues, String[] column, String orderBy) {
		Cursor cursor = null;
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			// 当传入的参数为空时，表示操作所有的记录
			if (whereArgs == null) {
				cursor = db.query(tableName, column, null, null, null, null,
						orderBy);
			} else {
				// 当传入的参数为一个时
				if (whereArgs.length == 1) {
					// 当传入的参数和参数值分别为一个时
					if (whereArgsValues.length == 1) {
						cursor = db.query(tableName, column, whereArgs[0]
								+ "= ?", whereArgsValues, null, null, orderBy);
					}
					// 当传入的参数为一个，参数值为多个时
					else {
						cursor = db.query(
								tableName,
								column,
								createSQL(whereArgs, whereArgsValues,
										whereArgsValues.length), null, null,
								null, orderBy);
					}
				}
				// 当传入的参数和参数值分别为多个时，并且参数和参数值是一一对应的
				else {
					cursor = db.query(
							tableName,
							column,
							createSQL(whereArgs, whereArgsValues,
									whereArgs.length), null, null, null,
							orderBy);
				}
			}
			// LogX.trace(TAG + "=================" + tableName,
			// "Query Success!");
			db.setTransactionSuccessful();
		} catch (Exception e) {
			// LogX.trace(TAG + "=================" + tableName, "Query Error!"
			// + ":" + e.getMessage());
			e.printStackTrace();
		} finally {
			db.endTransaction();
		}
		return cursor;
	}

	/**
	 * 对数据的更新操作
	 * 
	 * @param tableName
	 *            是所对应的操作表
	 * @param values
	 *            需要更新的数据名称和值组成的键值对
	 * @param whereArgs
	 *            要更新的数据集的条件参数
	 * @param whereArgsValues
	 *            要更新的数据集的条件参数的值
	 */
	public void update(String tableName, ContentValues values,
			String[] whereArgs, String[] whereArgsValues) {
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			if (whereArgs == null) {
				db.update(tableName, values, null, null);
			} else {
				// 当传入的参数为一个时
				if (whereArgs.length == 1) {
					// 当传入的参数和参数值分别为一个时
					if (whereArgsValues.length == 1) {
						db.update(tableName, values, whereArgs[0] + "='"
								+ whereArgsValues[0] + "'", null);
					}
					// 当传入的参数为一个，参数值为多个时
					else {
						db.update(
								tableName,
								values,
								createSQL(whereArgs, whereArgsValues,
										whereArgsValues.length), null);
					}
				}
				// 当传入的参数和参数值分别为多个时，并且参数和参数值是一一对应的
				else {
					db.update(
							tableName,
							values,
							createSQL(whereArgs, whereArgsValues,
									whereArgs.length), null);
				}
				// LogX.trace(TAG + "=================" + tableName,
				// "Query Success!");
			}
			db.setTransactionSuccessful();
		} catch (Exception e) {
			// LogX.trace(TAG + "=================" + tableName,
			// "Query Error!");
		} finally {
			db.endTransaction();
		}
	}

	/**
	 * 对数据批量更新操作
	 * 
	 * @param tableName
	 *            是所对应的操作表
	 * @param values
	 *            需要更新的数据名称和值组成的键值对
	 * @param whereArgs
	 *            要更新的数据集的条件参数
	 * @param whereArgsValues
	 *            要更新的数据集的条件参数的值
	 */
	public void updateByBatch(String tableName, Vector<ContentValues> values,
			String[] whereArgs, Vector<String[]> args) {
		if (values.size() == 0)
			return;
		db = this.getWritableDatabase();

		db.beginTransaction();
		try {
			if (whereArgs == null) {
				for (ContentValues value : values) {
					db.update(tableName, value, null, null);
				}
			} else {
				// 当传入的参数为一个时
				if (whereArgs.length == 1) {
					// 当传入的参数和参数值分别为一个时
					int i = 0;
					int length = args.size();
					for (; i < length; i++) {
						db.update(tableName, values.get(i), whereArgs[0] + "='"
								+ args.get(i)[0] + "'", null);
					}
				}
				// 当传入的参数和参数值分别为多个时，并且参数和参数值是一一对应的
				else {
					int i = 0;
					int length = args.size();
					for (; i < length; i++) {
						db.update(
								tableName,
								values.get(i),
								createSQL(whereArgs, args.get(i),
										whereArgs.length), null);
					}
				}
				// LogX.trace(TAG + "=================" + tableName,
				// "Query Success!");
			}
			db.setTransactionSuccessful();
		} catch (Exception e) {
			// LogX.trace(TAG + "=================" + tableName,
			// "Query Error!");
		} finally {
			db.endTransaction();
		}
	}

	/**
	 * 关闭所有链接中的数据库
	 */
	public void closeDatabase() {
		try {
			// close();
		} catch (Exception e) {
			// LogX.trace(TAG + "==================", "closeDatabase fail");
		}
	}

	public void closeDB() {
		try {
			close();
		} catch (Exception e) {
			// LogX.trace(TAG + "==================", "closeDatabase fail");
		}
	}

	/**
	 * 关闭当前正在使用的数据库
	 * 
	 * @param db
	 *            正处于打开状态的数据库
	 */
	public void close(SQLiteDatabase db) {
		try {
			if (db != null) {
				if (db.isOpen()) {
					db.close();
					db = null;
				}
			}
		} catch (Exception e) {
			// LogX.trace(TAG + "==================",
			// "closecurrentDatabase fail");
		}
	}

}
